{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-03-06T07:27:34.216080Z",
     "start_time": "2025-03-06T07:27:33.334975Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "source": "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取",
   "metadata": {
    "collapsed": false
   }
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "基本原理\n",
    "在机器学习里，很多算法要求输入的数据是数值类型的矩阵。然而，实际数据中常常包含非数值类型的数据，比如字符串。DictVectorizer 的作用就是将包含非数值类型数据的字典转换为数值矩阵，其中非数值类型的数据会被当作类别变量来处理，通常使用独热编码（One-Hot Encoding）。\n",
    "独热编码\n",
    "独热编码是一种将类别变量转换为数值向量的方法。对于一个具有 n 个不同类别的特征，独热编码会创建 n 个新的二进制特征，每个特征对应一个类别。在某个样本中，如果该样本属于某个类别，那么对应的二进制特征取值为 1，其余特征取值为 0。"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=False)  # 对字典数据进行特征抽取  把sparse改为True看看（为True则为稀疏存储,不存储0 ，这种存储方式的数据不可以直接喂给模型）\n",
    "    # DictVectorizer是一个类\n",
    "    # dict1 是DictVectorizer创造的一个对象，可以调用fit_transform方法进行特征抽取\n",
    "     \n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 对象dict1调用fit_transform可以把字典数据转换成特征矩阵\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                                {'city': '上海', 'temperature': 60},\n",
    "                                {'city': '深圳', 'temperature': 30}])  # 字典数据\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())  # 输出每个特征的名称\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-06T07:27:34.969901Z",
     "start_time": "2025-03-06T07:27:34.966047Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0.   1.   0. 100.]\n",
      " [  1.   0.   0.  60.]\n",
      " [  0.   0.   1.  30.]]\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词（如：I），默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "    # CountVectorizer是一个类\n",
    "    # vector是CountVectorizer创造的一个对象，可以调用fit_transform方法进行特征抽取\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())  # 输出每个特征的名称\n",
    "    print('-' * 50)\n",
    "    print(res)\n",
    "    print('-' * 50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-' * 50)\n",
    "    print(res.toarray())  #稀疏矩阵转换为数组，之后才能喂给模型（因为CountVectorizer没有sparse=False的选项）\n",
    "    print('-' * 50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))  # 不重要\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.038726Z",
     "start_time": "2025-03-05T00:55:04.034537Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我喜欢 python python\", \"人生漫长，不用 python\"])  # 如果是中文，默认按逗号和空格分割。这是时候就不合理，因为一句话被当成一个特征，这句话不会被分开，可能会非常的长。所以不可以用CountVectorizer\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(data)  #稀疏存储，只记录非零位置\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.043048Z",
     "start_time": "2025-03-05T00:55:04.039782Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '我喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))  # jieba.cut返回的是生成器（类似于range），可以用list()转换成列表。\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)  # 拼接后类型为str\n",
    "    c3 = ' '.join(content3)  # 这里用空格拼接起来，才能符合CountVectorizer的输入要求\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def Chinese_vec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  # jieba分词后的文本\n",
    "    print('-' * 50)\n",
    "    print(c1)  #把分词好的文本打印出来\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())  #把处理好后的特征名称打印出来\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# cutword()\n",
    "Chinese_vec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.399696Z",
     "start_time": "2025-03-05T00:55:04.044542Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n",
      "Loading model from cache C:\\Users\\HCS\\AppData\\Local\\Temp\\jieba.cache\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading model cost 0.347 seconds.\n",
      "Prefix dict has been built successfully.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)  # 创建tfidf对象\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())  # 输出每个特征的名称\n",
    "    print('-' * 50)\n",
    "    print(type(data))\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.408156Z",
     "start_time": "2025-03-05T00:55:04.400437Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "    # 用MinMaxScaler类创造一个对象，feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    fit_transform() 实际上是 fit() 和 transform() 两个方法的结合。它首先拟合（fit）模型，然后将数据转换（transform）为新的形式。通常情况下，fit_transform用于训练数据，即将训练数据输入到模型中进行拟合，并将其转换为新的形式。这个新的形式通常是一种更简单或更易于处理的形式，比如将数据缩放到相同的范围内或将其转换为主成分分析（PCA）的结果。\n",
    "    fit()：用于计算数据的一些统计信息，比如均值、标准差、最大值、最小值等，这些统计信息会被后续的转换操作所使用。简单来说，fit() 就是让模型 “学习” 数据的特征分布。\n",
    "    transform()：使用 fit() 阶段学到的统计信息对数据进行转换操作，比如将数据进行标准化、归一化等。transform 方法则是将数据转换为新形式，但不进行拟合（例如标准化，不会在测试集重新计算测试集的均值和方差）。它通常用于测试数据或新数据的转换。在这种情况下，我们已经有了训练好的模型，并且想要将新数据转换为与训练数据相同的形式，以便使用训练好的模型进行预测。\n",
    "    而 fit_transform() 会先执行 fit() 操作，然后紧接着执行 transform() 操作，这样可以更方便地完成数据的预处理。\n",
    "    \"\"\"\n",
    "    train_data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])  # 训练集\n",
    "\n",
    "    print(train_data)\n",
    "    print('-' * 50)\n",
    "    \"\"\"\n",
    "    transform()：使用之前 fit() 学到的统计信息对新的数据进行转换，常用于测试数据或新的未知数据，确保测试数据和训练数据使用相同的转换规则。\n",
    "    \"\"\"\n",
    "    test_data = mm.transform([[1, 2, 3, 4], [6, 5, 8, 7]])  # 测试集  用的是训练集中的min和max\n",
    "    print(test_data)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.415271Z",
     "start_time": "2025-03-05T00:55:04.409782Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "source": "(1 - 60) / 30",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.421782Z",
     "start_time": "2025-03-05T00:55:04.416234Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9666666666666666"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.],\n",
    "                              [2., 4., 2.],\n",
    "                              [4., 6., -1.]])\n",
    "\n",
    "    print(data)  # 标准化后的结果\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)  # 该数据集的均值（每一列的）\n",
    "    print('-' * 50)\n",
    "    print(std.var_)  # 该数据集的方差（每一列的）\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data = stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.426959Z",
     "start_time": "2025-03-05T00:55:04.422698Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.430483Z",
     "start_time": "2025-03-05T00:55:04.427799Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#如何求方差\n",
    "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.433703Z",
     "start_time": "2025-03-05T00:55:04.431292Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform(data)\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)\n",
    "\n",
    " # 事实证明，结果标准化后的结果确实符合均值为0，方差为1的分布。"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.438539Z",
     "start_time": "2025-03-05T00:55:04.434982Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.48029737e-16  7.40148683e-17  7.40148683e-17]\n",
      "[1. 1. 1.]\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "cell_type": "code",
   "source": "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.441767Z",
     "start_time": "2025-03-05T00:55:04.439441Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 19
  },
  {
   "cell_type": "code",
   "source": "(1 - 2.333) / np.sqrt(1.55555)",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.445070Z",
     "start_time": "2025-03-05T00:55:04.442577Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(-1.068779614944516)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 20
  },
  {
   "cell_type": "markdown",
   "source": "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差(也就是说用的都是训练集的均值方差)",
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:None\n",
    "    \"\"\"\n",
    "    # np.nan替换为均值\n",
    "    #mean, median, most_frequent(众数), constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.451413Z",
     "start_time": "2025-03-05T00:55:04.445892Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "cell_type": "code",
   "source": "11 / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.454797Z",
     "start_time": "2025-03-05T00:55:04.452305Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.6666666666666665"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 22
  },
  {
   "cell_type": "code",
   "source": "np.nan + 10",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.458131Z",
     "start_time": "2025-03-05T00:55:04.455686Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 23
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（特征变少）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    在机器学习中，特征的方差反映了该特征在数据集中的离散程度。如果一个特征的方差很小，意味着这个特征在不同样本之间的取值变化不大，比较稳定。从某种程度上来说，这样的特征可能没有携带足够多的有效信息来帮助模型区分不同的样本，对模型训练的贡献可能较小。\n",
    "    相反，方差较大的特征在不同样本之间的取值差异明显，更有可能蕴含着与目标变量相关的信息，能够为模型提供更多的区分度，所以在特征选择时，通常会保留方差较大的特征，删除方差较小的特征。\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))  # True表示返回列索引，False表示返回列名 用于人为检验删的特征有没有问题\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.464247Z",
     "start_time": "2025-03-05T00:55:04.459315Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "--------------------------------------------------\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 24
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5],\n",
    "                               [6, 3, 0, 8],\n",
    "                               [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum())  #最初数据每一列的方差，求和\n",
    "    print('-' * 50)\n",
    "    print(np.var(original_value, axis=0))  #最初数据每一列的方差\n",
    "    print('-' * 50)\n",
    "    \"\"\"\n",
    "    主成分分析的基本概念\n",
    "主成分分析（PCA）是一种无监督学习算法，主要用于数据的降维。它的核心思想是通过线性变换将原始数据转换到一组新的正交特征（即主成分）上，这些主成分按照方差从大到小排列，方差越大表示该主成分所包含的原始数据信息越多。\n",
    "n_components = 0.9 的作用\n",
    "n_components 参数可以接受不同类型的值，当它的值为 0 到 1 之间的浮点数时，如 n_components = 0.9，表示我们希望选择足够的主成分，使得这些主成分能够解释原始数据总方差的 90%。\n",
    "具体来说，在进行 PCA 降维时，算法会计算出一系列的主成分，每个主成分都有对应的方差，所有主成分的方差之和等于原始数据的总方差。n_components = 0.9 意味着 PCA 算法会自动选择前面若干个主成分，使得这些主成分的方差之和占原始数据总方差的比例达到 90%。这样做的好处是在降维的同时，尽可能多地保留原始数据的信息。\n",
    "    \"\"\"\n",
    "    pca = PCA(n_components=0.9)  # 参数代表：保留90%的方差\n",
    "    # 小数表示保留90%的方差，整数表示降维到指定维度\n",
    "\n",
    "    data = pca.fit_transform(original_value)  # 降维\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差和\n",
    "    print(np.var(data, axis=0).sum())  # 降维后每一列的方差，求和\n",
    "    print('-' * 50)\n",
    "    print(np.var(data, axis=0))  # 降维后每一列的方差\n",
    "    print('-' * 50)\n",
    "    print(pca.explained_variance_ratio_)  # 各主成分的方差占总方差的比例\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.478569Z",
     "start_time": "2025-03-05T00:55:04.467647Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[ 2.88888889  4.66666667 13.55555556  8.22222222]\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[22.          7.33333333]\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 25
  },
  {
   "cell_type": "code",
   "source": "22 / 29.333333333333336",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:04.481835Z",
     "start_time": "2025-03-05T00:55:04.479368Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7499999999999999"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 26
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x = np.random.rand(1000)  #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t, x, 'g.', label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-05T00:55:05.352547Z",
     "start_time": "2025-03-05T00:55:04.482701Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 27
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
